home *** CD-ROM | disk | FTP | other *** search
/ Best Tools for JAVA / Best Tools for JAVA.iso / POSTSCPT / GS3.53 / GS_FONTS.PS < prev    next >
Encoding:
Text File  |  1996-01-10  |  22.4 KB  |  733 lines
  1. %    Copyright (C) 1990, 1995 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Font initialization and management code.
  19.  
  20. % Define the default font.
  21. /defaultfontname /Courier def
  22.  
  23. % Define the name of the font map file.
  24. /FONTMAP dup where { pop pop } { (Fontmap) def } ifelse
  25.  
  26. % If DISKFONTS is true, we load individual CharStrings as they are needed.
  27. % (This is intended primarily for machines with very small memories.)
  28. % In this case, we define another dictionary, parallel to FontDirectory,
  29. % that retains an open file for every font loaded.
  30. /FontFileDirectory 10 dict def
  31.  
  32. % Load the font name -> font file name map.
  33. userdict /Fontmap FontDirectory maxlength dict put
  34. /.loadFontmap        % <file> .loadFontmap -
  35.  {  { dup token not { closefile exit } if
  36.         % stack: <file> fontname
  37.       1 index token not
  38.        { (Fontmap entry for ) print dup =only
  39.      ( has no associated file or alias name!  Giving up.\n) print flush
  40.      {.loadFontmap} 0 get 1 .quit
  41.        } if
  42.       dup type dup /stringtype eq exch /nametype eq or not
  43.        { (Fontmap entry for ) print 1 index =only
  44.      ( has an invalid file or alias name!  Giving up.\n) print flush
  45.      {.loadFontmap} 0 get 1 .quit
  46.        } if
  47.         % stack: <file> fontname filename|aliasname
  48.         % Read and pop tokens until a semicolon.
  49.        { 2 index token not
  50.       { (Fontmap entry for ) print 1 index =only
  51.         ( ends prematurely!  Giving up.\n) print flush
  52.         {.loadFontmap} 0 get 1 .quit
  53.       } if
  54.      dup /; eq { pop .definefontmap exit } if
  55.      pop
  56.        } loop
  57.     } loop 
  58.  } bind def
  59. % Make an entry in Fontmap.  We redefine this if the Level 2
  60. % resource machinery is loaded.
  61. /.definefontmap            % <fontname> <file|alias> .definefontmap -
  62.  { Fontmap 3 1 roll .growput
  63.  } bind def
  64.  
  65. % Parse a font file just enough to find the FontName or FontType.
  66. /.findfontvalue        % <file> <key> .findfontvalue <value> true
  67.             % <file> <key> .findfontvalue false
  68.             % Closes the file in either case.
  69.  { exch dup read not { -1 } if
  70.    2 copy unread 16#80 eq
  71.     { dup (xxxxxx) readstring pop pop }        % skip .PFB header
  72.    if
  73.         % Stack: key file
  74.     { dup token not { false exit } if        % end of file
  75.       dup /eexec eq { pop false exit } if    % reached eexec section
  76.       dup /Subrs eq { pop false exit } if    % Subrs without eexec
  77.       dup /CharStrings eq { pop false exit } if    % CharStrings without eexec
  78.       dup 3 index eq
  79.        { xcheck not { dup token exit } if }    % found key
  80.        { pop }
  81.       ifelse
  82.     } loop
  83.         % Stack: key file value true   (or)
  84.         % Stack: key file false
  85.    dup { 4 } { 3 } ifelse -2 roll closefile pop
  86.  } bind def
  87. /.findfontname
  88.  { /FontName .findfontvalue
  89.  } bind def
  90.  
  91. % If there is no FONTPATH, try to get one from the environment.
  92. NOFONTPATH { systemdict /FONTPATH undef (%END FONTPATH) .skipeof } if
  93. /FONTPATH where
  94.  { pop
  95.  }
  96.  { (GS_FONTPATH) getenv
  97.     { /FONTPATH exch def }
  98.     { (%END FONTPATH) .skipeof }
  99.    ifelse
  100.  }
  101. ifelse
  102.  
  103. % Scan directories looking for plausible fonts.  "Plausible" means that
  104. % the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
  105. % followed by four arbitrary bytes and then either of these strings.
  106. % To speed up the search, we skip any file whose name appears in
  107. % the Fontmap (with any extension and upper/lower case variation) already,
  108. % and any file whose extension definitely indicates it is not a font.
  109. %
  110. % NOTE: The current implementation of this procedure is Unix/DOS-
  111. % specific.  It assumes that '/' and '\' are directory separators; that
  112. % the part of a file name following the last '.' is the extension;
  113. % that ';' cannot appear in a file name; and that ':' can appear in a
  114. % file name only if the file name doesn't begin with '/', '\', or '.'.
  115. % (this is so that Unix systems can use ':' as the separator).
  116. %
  117. /.lowerstring        % <string> .lowerstring <lowerstring>
  118.  { 0 1 2 index length 1 sub
  119.     { 2 copy get dup 65 ge exch 90 le and
  120.        { 2 copy 2 copy get 32 add put }
  121.      if pop
  122.     }
  123.    for
  124.  } bind def
  125. /.splitfilename        % <dir.../base.extn> .basename <base> <extn>
  126.  {  { (/) search { true } { (\\) search } ifelse
  127.        { pop pop }
  128.        { exit }
  129.       ifelse
  130.     }
  131.    loop
  132.    dup { (.) search { pop pop } { exit } ifelse } loop
  133.    2 copy eq
  134.     { pop () }
  135.     { exch dup length 2 index length 1 add sub 0 exch getinterval exch }
  136.    ifelse
  137. % Following is debugging code.
  138. %   (*** Split => ) print 2 copy exch ==only ( ) print ==only
  139. %   ( ***\n) print flush
  140.  } bind def
  141. /.scanfontdict Fontmap maxlength dict def
  142. /.scanfontbegin
  143.  {    % Construct the table of all file names already in Fontmap.
  144.    Fontmap
  145.     { exch pop dup type /stringtype eq
  146.        { .splitfilename pop =string copy .lowerstring cvn
  147.      .scanfontdict exch true .growput
  148.        }
  149.        { pop
  150.        }
  151.       ifelse
  152.     }
  153.    forall
  154.  } bind def
  155. /.scanfontskip mark
  156.         % Strings are converted to names anyway, so....
  157.   /afm true
  158.   /bat true
  159.   /c true
  160.   /cmd true
  161.   /com true
  162.   /dll true
  163.   /doc true
  164.   /exe true
  165.   /h true
  166.   /o true
  167.   /obj true
  168.   /pfm true
  169.   /txt true
  170. .dicttomark def
  171. /.scan1fontstring 128 string def
  172. /.fontheaders [(%!PS-AdobeFont*) (%!FontType1*)] def
  173. 0 .fontheaders { length max } forall 6 add    % extra for PFB header
  174. /.scan1fontfirst exch string def
  175. /.scan1fontdir        % <dirname> .scan1fontdir -
  176.  { QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
  177.    (/*) concatstrings 0 0 0 4 -1 roll    % found scanned files
  178.     {        % stack: <fontcount> <scancount> <filecount> <filename>
  179.       exch 1 add exch                   % increment filecount
  180.       dup .splitfilename .lowerstring
  181.         % stack: <fontcount> <scancount> <filecount+1> <filename>
  182.         %    <BASE> <ext>
  183.       .scanfontskip exch known exch .scanfontdict exch known or
  184.        { pop
  185.         % stack: <fontcount> <scancount> <filecount+1>
  186.        }
  187.        { 3 -1 roll 1 add 3 1 roll
  188.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  189.      dup (r) { file } stopped
  190.       { pop pop null () 
  191.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  192.         %    null ()
  193.       }
  194.       { 
  195.         % On some platforms, the file operator will open directories,
  196.         % but an error will occur if we try to read from one.
  197.         % Handle this possibility here.
  198.         dup .scan1fontfirst { readstring } stopped
  199.          { pop pop () }
  200.          { pop }
  201.         ifelse 
  202.         % stack: <fontcount> <scancount+1> <filecount+1>
  203.         %    <filename> <file> <header>
  204.       }
  205.      ifelse
  206.         % Check for PFB file header.
  207.      dup (\200\001????*) .stringmatch
  208.       { dup length 6 sub 6 exch getinterval }
  209.      if
  210.         % Check for font file headers.
  211.      false .fontheaders { 2 index exch .stringmatch or } forall exch pop
  212.       {    % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  213.         %    <file>
  214.         dup 0 setfileposition .findfontname
  215.          { dup Fontmap exch known
  216.         { pop pop
  217.         }
  218.         { exch copystring exch
  219.           DEBUG { ( ) print dup =only } if
  220.           1 index .definefontmap
  221.           .splitfilename pop true .scanfontdict 3 1 roll .growput
  222.             % Increment fontcount.
  223.           3 -1 roll 1 add 3 1 roll
  224.         }
  225.            ifelse
  226.          }
  227.         if
  228.       }
  229.         % .findfontname will have done a closefile in the above case.
  230.       { dup null eq { pop } { closefile } ifelse pop 
  231.       }
  232.      ifelse
  233.        }
  234.       ifelse
  235.     }
  236.    .scan1fontstring filenameforall
  237.    QUIET
  238.     { pop pop pop }
  239.     { ( ) print =only ( files, ) print =only ( scanned, ) print
  240.       =only ( new fonts.\n) print flush
  241.     }
  242.    ifelse
  243.  } bind def
  244. % Scan all the directories mentioned in FONTPATH (or GS_FONTPATH).
  245. /.scanfontpath
  246.  { .scanfontbegin
  247.     % Parsing the list of dictionaries is messy, since we have to
  248.     % handle both the Unix : and the other-system ; as separators.
  249.     % See the earlier comment for the restrictions that make this work.
  250.    FONTPATH
  251.     { dup length 0 eq { pop exit } if
  252.       (;) search
  253.        { exch pop
  254.        }
  255.        { dup 0 1 getinterval (/\\.) exch search
  256.       { pop pop pop (:) search
  257.          { exch pop }
  258.          { () exch }
  259.         ifelse
  260.       }
  261.       { pop () exch
  262.       }
  263.      ifelse
  264.        }
  265.       ifelse .scan1fontdir
  266.     }
  267.    loop
  268.  } bind def
  269.  
  270. %END FONTPATH
  271.  
  272. % Define definefont.  This is a procedure built on a set of operators
  273. % that do all the error checking and key insertion.
  274. mark
  275.     /.buildfont0 where { pop 0 /.buildfont0 cvx } if
  276.     /.buildfont1 where { pop 1 /.buildfont1 cvx } if
  277.     /.buildfont3 where { pop 3 /.buildfont3 cvx } if
  278.     /.buildfont4 where { pop 4 /.buildfont4 cvx } if
  279. .dicttomark /buildfontdict exch def
  280. /.growfontdict
  281.  {    % Grow the font dictionary, if necessary, to ensure room for an
  282.     % added entry, making sure there is at least one slot left for FID.
  283.    dup maxlength 1 index length sub 2 lt
  284.     { dup dup wcheck
  285.        { .growdict }
  286.        { .growdictlength dict copy }
  287.       ifelse
  288.     }
  289.     { dup wcheck not { dup maxlength dict copy } if
  290.     }
  291.    ifelse
  292.  } bind def  
  293. /definefont
  294.  { 1 dict begin count /d exch def    % save stack depth in case of error
  295.     {        % Check for disabled platform fonts.
  296.       NOPLATFONTS
  297.        {    % Make sure we leave room for FID.
  298.      .growfontdict dup /ExactSize 0 put
  299.        }
  300.        {    % Hack: if the Encoding looks like it might be the
  301.         % Symbol or Dingbats encoding, load those now (for the
  302.         % benefit of platform font matching) just in case
  303.         % the font didn't actually reference them.
  304.      dup /Encoding get length 65 ge
  305.       { dup /Encoding get 64 get
  306.         dup /congruent eq { SymbolEncoding pop } if
  307.         /a9 eq { DingbatsEncoding pop } if
  308.       }
  309.      if
  310.        }
  311.       ifelse
  312.       dup /FontType get //buildfontdict exch get exec
  313.       DISKFONTS
  314.        { FontFileDirectory 2 index known
  315.       { dup /FontFile FontFileDirectory 4 index get .growput
  316.       }
  317.      if
  318.        }
  319.       if
  320.       readonly
  321.     }
  322.    stopped
  323.     { count d sub { pop } repeat end /invalidfont signalerror
  324.     }
  325.     { end        % stack: name fontdict
  326.         % If the current allocation mode is global, also enter
  327.         % the font in LocalFontDirectory.
  328.       .currentglobal
  329.        { systemdict /LocalFontDirectory .knownget
  330.       { 2 index 2 index .growput }
  331.      if
  332.        }
  333.       if
  334.       dup FontDirectory 4 -2 roll .growput
  335.     }
  336.    ifelse
  337.  } odef
  338.  
  339. % Define a procedure for defining aliased fonts.
  340. % We can't just copy the font (or even use the same font unchanged),
  341. % because a significant number of PostScript files assume that
  342. % the FontName of a font is the same as the font resource name or
  343. % the key in [Shared]FontDirectory; on the other hand, some Adobe files
  344. % rely on the FontName of a substituted font *not* being the same as
  345. % the requested resource name.  We address this issue heuristically:
  346. % we substitute the new name iff the font name doesn't have MM in it.
  347. /.aliasfont        % <name> <font> .aliasfont <newFont>
  348.  { .currentglobal 3 1 roll dup .gcheck .setglobal
  349.    dup length 2 add dict
  350.    dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
  351.         % Stack: global fontname newfont newfont.
  352.         % We might be defining a global font whose FontName
  353.         % is a local string.  This is weird, but legal,
  354.         % and doesn't cause problems anywhere else.
  355.         % To avoid any possible problems, do a cvn.
  356.    2 index =string cvs (MM) search
  357.     { pop pop pop pop
  358.     }
  359.     { /FontName exch dup type /stringtype eq { cvn } if put
  360.     }
  361.    ifelse
  362.    systemdict /definefont get exec    % Don't bind, since Level 2
  363.                     % redefines definefont
  364.    exch .setglobal
  365.  } odef        % so findfont will bind it
  366.  
  367. % Define .loadfontfile for loading a font.  If we recognize Type 1 fonts,
  368. % gs_type1.ps will redefine this.
  369. /.loadfontfile { cvx exec } bind def
  370. /.loadfont
  371.  {        % Some buggy fonts leave extra junk on the stack,
  372.         % so we have to make a closure that records the stack depth
  373.         % in a fail-safe way.
  374.    /.loadfontfile cvx count 1 sub 2 packedarray cvx exec
  375.    count exch sub { pop } repeat
  376.  } bind def
  377.  
  378. % Find an alternate font to substitute for an unknown one.
  379. % We go to some trouble to parse the font name and extract
  380. % properties from it.  Later entries take priority over earlier.
  381. /.substitutefaces [
  382.     % Guess at suitable substitutions for random unknown fonts.
  383.   [(Grot) /Times]
  384.   [(Roman) /Times]
  385.   [(Book) /NewCenturySchlbk]
  386.     % If the family name appears in the font name,
  387.     % use a font from that family.
  388.   [(Arial) /Helvetica]
  389.   [(Avant) /AvantGarde]
  390.   [(Bookman) /Bookman]
  391.   [(Century) /NewCenturySchlbk]
  392.   [(Cour) /Courier]
  393.   [(Geneva) /Helvetica]
  394.   [(Helv) /Helvetica]
  395.   [(NewYork) /Times]
  396.   [(Pala) /Palatino]
  397.   [(Sans) /Helvetica]
  398.   [(Schlbk) /NewCenturySchlbk]
  399.   [(Serif) /Times]
  400.   [(Swiss) /Helvetica]
  401.   [(Times) /Times]
  402.     % Substitute for Adobe Multiple Master fonts.
  403.   [(Myriad) /Times]
  404.   [(Minion) /Helvetica]
  405.     % Condensed or narrow fonts map to the only narrow family we have.
  406.   [(Cond) /Helvetica-Narrow]
  407.   [(Narrow) /Helvetica-Narrow]
  408.     % If the font wants to be monospace, use Courier.
  409.   [(Monospace) /Courier]
  410.   [(Typewriter) /Courier]
  411. ] readonly def
  412. /.substituteproperties [
  413.   [(It) 1] [(Oblique) 1]
  414.   [(Bd) 2] [(Bold) 2] [(bold) 2] [(Demi) 2] [(Heavy) 2] [(Sb) 2]
  415. ] readonly def
  416. /.substitutefamilies mark
  417.   /AvantGarde
  418.     {/AvantGarde-Book /AvantGarde-BookOblique
  419.      /AvantGarde-Demi /AvantGarde-DemiOblique}
  420.   /Bookman
  421.     {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
  422.   /Courier
  423.     {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
  424.   /Helvetica
  425.     {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  426.   /Helvetica-Narrow
  427.     {/Helvetica-Narrow /Helvetica-Narrow-Oblique
  428.      /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
  429.   /NewCenturySchlbk
  430.     {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
  431.      /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
  432.   /Palatino
  433.     {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
  434.   /Times
  435.     {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
  436. .dicttomark readonly def
  437. /.substitutefont        % <fontname> .substitutefont <altname>
  438.  {    % Look for properties and/or a face name in the font name.
  439.     % If we find any, use Helvetica as the base font;
  440.     % otherwise, use the default font.
  441.     % Note that the "substituted" font name may be the same as
  442.     % the requested one; the caller must check this.
  443.    dup length string cvs
  444.     {defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  445.    exch 0 exch    % stack: fontname facelist properties fontname
  446.     % Look for a face name.
  447.    .substitutefaces
  448.     { 2 copy 0 get search
  449.        { pop pop pop 1 get .substitutefamilies exch get
  450.      4 -1 roll pop 3 1 roll
  451.        }
  452.        { pop pop
  453.        }
  454.       ifelse
  455.     }
  456.    forall
  457.    .substituteproperties
  458.     { 2 copy 0 get search
  459.        { pop pop pop 1 get 3 -1 roll or exch }
  460.        { pop pop }
  461.       ifelse
  462.     }
  463.    forall pop get
  464.     % If SUBSTFONT is defined, use it.
  465.    /SUBSTFONT where
  466.     { pop pop /SUBSTFONT load cvn }
  467.     { exec }
  468.    ifelse
  469.     % Only accept fonts known in the Fontmap.
  470.    Fontmap 1 index known not { pop defaultfontname } if
  471.  } bind def
  472.  
  473. % If requested, make (and recognize) fake entries in FontDirectory for fonts
  474. % present in Fontmap but not actually loaded.  Thanks to Ray Johnston for
  475. % the idea behind this code.
  476. FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
  477.  
  478. % We use the presence or absence of the FontMatrix key to indicate whether
  479. % a font is real or fake.
  480.  
  481. /definefont        % <name> <font> definefont <font>
  482.  { dup /FontMatrix known not { /FontName get findfont } if
  483.    //definefont
  484.  } bind odef
  485.  
  486. /scalefont        % <font> <scale> scalefont <font>
  487.  { exch dup /FontMatrix known not { /FontName get findfont } if
  488.    exch //scalefont
  489.  } bind odef
  490.  
  491. /makefont        % <font> <matrix> makefont <font>
  492.  { exch dup /FontMatrix known not { /FontName get findfont } if
  493.    exch //makefont
  494.  } bind def
  495.  
  496. /setfont        % <font> setfont -
  497.  { dup /FontMatrix known not { /FontName get findfont } if
  498.    //setfont
  499.  } bind odef
  500.  
  501. %END FAKEFONTS
  502.  
  503. % Define findfont so it tries to load a font if it's not found.
  504. % The Red Book requires that findfont be a procedure, not an operator.
  505. /findfont
  506.  {    % Since PostScript has no concept of goto, or even blocks with
  507.     % exits, we use a loop as a way to get an exitable scope.
  508.     % The loop is never executed more than once.
  509.    mark exch
  510.     { .findfontloop
  511.     } stopped
  512.     { counttomark 1 sub { pop } repeat exch pop stop
  513.     }
  514.     {    % Define any needed aliases.
  515.       counttomark 1 sub { .aliasfont } repeat
  516.       exch pop
  517.     }
  518.    ifelse
  519.  } bind def
  520. /.checkalias        % -mark- <alias1> ... <name> .checkalias <<same>>
  521.  { counttomark 1 sub -1 1
  522.     { index 1 index eq
  523.        {        % We're about to try finding a font that's already
  524.             % in our list of aliases, so we're in a loop.
  525.      pop QUIET not
  526.       { (Unable to substitute for font.\n) print flush
  527.       } if
  528.      /findfont cvx /invalidfont signalerror
  529.        }
  530.       if
  531.     }
  532.    for
  533.  } bind def
  534. /.fontknownget        % <fontdir> <fontname> .fontknown <font> true
  535.             % <fontdir> <fontname> .fontknown false
  536.  { .knownget
  537.     { FAKEFONTS
  538.        { dup /FontMatrix known { true } { pop false } ifelse }
  539.        { true }
  540.       ifelse
  541.     }
  542.     { false
  543.     }
  544.    ifelse
  545.  } bind def
  546. /.findfontloop
  547.  {            % We eventually exit this loop with either
  548.             % <font> true or false on the top of the stack.
  549.     {
  550.         % Stack: mark <alias>* fontname
  551.  
  552.             % Already loaded?
  553.     FontDirectory 1 index .fontknownget
  554.      { exch pop true exit }
  555.     if
  556.  
  557.             % Unknown font name?
  558.     dup Fontmap exch .knownget not
  559.      { false exit }
  560.     if
  561.  
  562.             % Font alias?
  563.     dup type /nametype eq
  564.      { .checkalias .findfontloop true exit }
  565.     if
  566.  
  567.             % Font with a procedural definition?
  568.     dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
  569.      { exec        % The procedure will load the font.
  570.             % Check to make sure this really happened.
  571.        FontDirectory 1 index .knownget
  572.         { exch pop true }
  573.         { false }
  574.        ifelse exit
  575.      }
  576.     if
  577.  
  578.             % Can we open the file?
  579.     findlibfile not
  580.      { QUIET not
  581.         { (Can't find \(or can't open\) font file ) print dup print
  582.           (.\n) print flush
  583.         }
  584.        if pop false exit
  585.      }
  586.     if
  587.  
  588.             % Stack: fontname fontfilename fontfile
  589.     DISKFONTS
  590.      { .currentglobal true .setglobal
  591.        2 index (r) file
  592.        FontFileDirectory exch 4 index exch .growput
  593.        .setglobal
  594.      }
  595.     if
  596.     QUIET not
  597.      { (Loading ) print 2 index =only
  598.        ( font from ) print 1 index print (... ) print flush
  599.      }
  600.     if
  601.     % If LOCALFONTS isn't set, load the font into local or global
  602.     % VM according to FontType; if LOCALFONTS is set, load the font
  603.     % into the current VM, which is what Adobe printers (but not
  604.     % DPS or CPSI) do.
  605.     LOCALFONTS { false } { /setglobal where } ifelse
  606.      { pop /FontType .findfontvalue { 1 eq } { false } ifelse
  607.         % .setglobal, like setglobal, aliases FontDirectory to
  608.         % GlobalFontDirectory if appropriate.  However, we mustn't
  609.         % allow the current version of .setglobal to be bound in,
  610.         % because it's different depending on language level.
  611.        .currentglobal exch /.setglobal load exec
  612.         % Remove the fake definition, if any.
  613.        FontDirectory 3 index undef
  614.        1 index (r) file .loadfont FontDirectory exch
  615.        /.setglobal load exec
  616.      }
  617.      { .loadfont FontDirectory
  618.      }
  619.     ifelse
  620.         % Stack: fontname fontfilename fontdirectory
  621.     QUIET not
  622.      { systemdict /level2dict known
  623.         { .currentglobal false .setglobal vmstatus
  624.           true .setglobal vmstatus 3 -1 roll pop
  625.           6 -1 roll .setglobal 5
  626.         }
  627.         { vmstatus 3
  628.         }
  629.        ifelse { =only ( ) print } repeat
  630.        (done.\n) print flush
  631.      } if
  632.  
  633.         % Check to make sure the font was actually loaded.
  634.     dup 3 index .fontknownget
  635.      { 4 1 roll pop pop pop true exit } if
  636.  
  637.         % Maybe the file had a different FontName.
  638.         % See if we can get a FontName from the file, and if so,
  639.         % whether a font by that name exists now.
  640.     exch (r) file .findfontname
  641.      { 2 copy .fontknownget
  642.         {    % Yes.  Stack: origfontname fontdirectory filefontname fontdict
  643.           3 -1 roll pop exch
  644.           QUIET
  645.            { pop
  646.            }
  647.            { (Using ) print =only
  648.              ( font for ) print 1 index =only
  649.              (.\n) print flush
  650.            }
  651.           ifelse true exit
  652.         }
  653.        if pop
  654.      }
  655.     if pop
  656.  
  657.         % The font definitely did not load correctly.
  658.     QUIET not
  659.      { (Loading ) print dup =only
  660.        ( font failed.\n) print flush
  661.      } if
  662.     false exit
  663.  
  664.     } loop        % end of loop
  665.  
  666.             % Check whether we actually got a font.
  667.    not
  668.     { dup defaultfontname eq
  669.        { QUIET not
  670.       { (Unable to load default font ) print
  671.          dup =only (!  Giving up.\n) print flush
  672.       }
  673.      if /findfont cvx /invalidfont signalerror
  674.        }
  675.       if dup .substitutefont
  676.       2 copy eq { pop defaultfontname } if
  677.       .checkalias
  678.       QUIET not
  679.        { (Substituting font ) print dup =only ( for ) print
  680.      1 index =only (.\n) print flush
  681.        }
  682.       if .findfontloop
  683.     }
  684.    if
  685.  
  686.  } bind def
  687.  
  688. % Define a procedure to load all known fonts.
  689. % This isn't likely to be very useful.
  690. /loadallfonts
  691.  { Fontmap { pop findfont pop } forall
  692.  } bind def
  693.  
  694. % Install initial fonts from FONTPATH or Fontmap.
  695. /.loadinitialfonts
  696.  { /FONTPATH where
  697.     { pop DEBUG { (gs_fonts .scanfontpath) = } if
  698.       .scanfontpath
  699.     }
  700.     { NOFONTMAP not
  701.        { FONTMAP VMDEBUG
  702.      FONTMAP findlibfile
  703.       { exch pop .loadFontmap }
  704.       { FONTMAP /undefinedfilename signalerror }
  705.      ifelse
  706.        }
  707.       if
  708.     }
  709.    ifelse
  710.  
  711.    FAKEFONTS
  712.     { (gs_fonts FAKEFONTS) VMDEBUG
  713.     % Now load all the fonts defined in the Fontmap into FontDirectory
  714.     % as "fake" fonts i.e., font dicts with only FontName defined.
  715.     % We must ensure that this happens in both global and local
  716.     % directories.
  717.       2
  718.     { .currentglobal not .setglobal
  719.       Fontmap
  720.        { pop dup type /stringtype eq { cvn } if
  721.          FontDirectory 1 index known not
  722.           { 1 dict dup /FontName 3 index put        
  723.             FontDirectory 3 1 roll put
  724.           }
  725.          if
  726.        }
  727.       forall
  728.        }
  729.       repeat
  730.     } if
  731.  
  732.  } def            % don't bind, .current/setglobal get redefined
  733.